const STREET_LABEL_ID = 68001
export const getCenterPoint = (center) => {
  if (!center) {
    return { lat: 0, lng: 0 }
  }

  // 处理WKT格式的点数据
  try {
    // 匹配POINT格式: POINT (longitude latitude)
    const pointMatch = center.match(/POINT\s*\(\s*([\d.-]+)\s+([\d.-]+)\s*\)/i)

    if (pointMatch && pointMatch.length >= 3) {
      // 提取经纬度（注意WKT格式通常是x y顺序，对应longitude latitude）
      const longitude = parseFloat(pointMatch[1])
      const latitude = parseFloat(pointMatch[2])

      if (!isNaN(latitude) && !isNaN(longitude)) {
        return { lat: latitude, lng: longitude }
      }
    }

    // 如果不是WKT格式，尝试使用原来的逗号分隔格式作为后备
    const [lng, lat] = center.split(',')
    if (lng && lat) {
      return { lat: Number(lat), lng: Number(lng) }
    }
  } catch (error) {
    console.error('解析WKT点数据失败:', error)
  }

  return { lat: 0, lng: 0 }
}

// 解析WKT格式的Polygon数据
export const parseWktPolygon = (wkt) => {
  // 匹配多边形的坐标部分
  const polygonMatch = wkt.match(
    /POLYGON\s*\(\s*\((.*?)\)\s*(?:,\s*\((.*?)\))*\s*\)/i
  )
  if (!polygonMatch) {
    return []
  }

  // 存储所有环的数据
  const rings = []

  // 第一个捕获组是外环，后续的是内环
  for (let i = 1; i < polygonMatch.length; i++) {
    if (polygonMatch[i]) {
      const ringCoords = parseCoordinates(polygonMatch[i])
      if (ringCoords.length > 0) {
        rings.push(ringCoords)
      }
    }
  }

  return rings
}

// 解析坐标字符串，返回[{latitude, longitude}]格式
export const parseCoordinates = (coordsStr) => {
  // 分割坐标点
  const coordsArray = coordsStr.split(',')
  const points = []

  coordsArray.forEach((coordPair) => {
    // 去除空格并分割经纬度
    const pair = coordPair.trim().split(/\s+/)
    if (pair.length >= 2) {
      // WKT格式通常是x y顺序，对应longitude latitude
      const longitude = parseFloat(pair[0])
      const latitude = parseFloat(pair[1])

      if (!isNaN(longitude) && !isNaN(latitude)) {
        points.push({ latitude, longitude })
      }
    }
  })

  return points
}

export const getPolygonDatas = (datas) => {
  // 处理传入的多边形数据
  if (!datas || !Array.isArray(datas)) {
    return {lines:[],polygons:[]}
  }

  // 存储所有处理后的多边形数据
  const lines = []
  const polygonsList = []

  datas.forEach((item) => {
    if (!item || !item.polygon) {
      return {lines:[],polygons:[]}
    }

    const wkt = item.polygon.trim()
    // 解析WKT格式的多边形数据
    try {
      const polygonData = parseWktPolygon(wkt)
      if (polygonData && polygonData.length > 0) {
        polygonData.forEach((points) => {
          lines.push({
            points,
            color: '#0881FE', // 蓝色
            width: 5,
            dottedLine: true, // 设置虚线
          })
          polygonsList.push({
            points,
            fillColor: '#0881FE30', // 蓝色
            strokeWidth:0
          })
        })
      }
    } catch (error) {
      console.error('解析WKT数据失败:', error)
    }
  })
  return {lines:lines,polygons:polygonsList}
}

export const createLabel = (datas) => {
  return datas.map((item, index) => ({
    markerId: STREET_LABEL_ID + index,
    latitude: item.latitude,
    longitude: item.longitude,
    width: 1,
    height: 1,
    iconPath: '/static/1.png',
    anchor: {
      x: 0,
      y: 0,
    },
    callout: {
      content: `<div style="color:#000000;font-size:18px;font-weight:bold;line-height:24px;">${item.name}</div>`,
      padding: 1,
      borderWidth: 0,
      borderColor: 'transparent',
      borderRadius: 0,
      bgColor: 'transparent',
      boxShadow: 'none',
      display: 'ALWAYS',
    },
  }))
}


export const gotoAutonaive = (longitude,latitude,name) => {
  uni.openLocation({
    latitude,
    longitude,
    name,
    scale: 18,
    success: function (res) {
      console.log(res)
    },
    fail: function (err) {
      console.log(err)
    },
  })
}

export const openAmap = (longitude, latitude,name) => {
  uni.navigateToMiniProgram({
    appId: '1108836237',
    path: `pages/direction/direction?sourceApplication=applicationName&dname=${encodeURIComponent(
      name
    )}&dev=0&t=0&slat=&slon=&sname=&dlat=${latitude}&dlon=${longitude}`,
    extraData: {
      sourceApplication: 'applicationName',
    },
    success(res) {
      console.log('打开高德地图小程序成功', res)
    },
    fail(err) {
      console.error('打开高德地图小程序失败', err)
      // 如果打开小程序失败，则尝试使用H5链接
      window.location.href = `https://uri.amap.com/marker?position=${longitude},${latitude}&name=${encodeURIComponent(
        name
      )}`
    },
  })
}


export const getBoundsBox = (points) => { 
  if (!points || points.length === 0) {
    return null
  }

  let minLat = points[0].latitude
  let maxLat = points[0].latitude
  let minLng = points[0].longitude
  let maxLng = points[0].longitude

  for (const point of points) {
    minLat = Math.min(minLat, point.latitude)
    maxLat = Math.max(maxLat, point.latitude)
    minLng = Math.min(minLng, point.longitude)
    maxLng = Math.max(maxLng, point.longitude)
  }

  return [
    {
      latitude: minLat,
      longitude: minLng,
    },
    {
      latitude: maxLat,
      longitude: maxLng,
    }
  ]
}